// alert.go
package model

import (
	"fmt"
	"strconv"
	"time"
)

// {
//   "id": 81627,                                // 告警ID - 唯一标识符
//   "cate": "prometheus",                       // 告警类别 - 数据源类型（如prometheus）
//   "cluster": "172.16.15.110普罗米修斯",        // 集群名称 - 产生告警的监控集群
//   "datasource_id": 3,                         // 数据源ID - 监控数据源的唯一标识
//   "group_id": 3,                              // 分组ID - 告警所属的分组ID
//   "group_name": "运维团队",                    // 分组名称 - 告警所属的团队或业务线
//   "hash": "bdb67c329106d11aa28b8c787632c35e", // 告警哈希 - 用于唯一标识告警
//   "rule_id": 8,                               // 规则ID - 触发告警的监控规则ID
//   "rule_name": "运维团队测试告警11",           // 规则名称 - 触发告警的监控规则名称
//   "rule_note": "111",                         // 规则备注 - 规则的描述信息
//   "rule_prod": "metric",                      // 规则产品 - 规则所属的产品类型
//   "rule_algo": "",                            // 规则算法 - 使用的告警算法
//   "severity": 2,                              // 严重级别 - 1:提示, 2:警告, 3:严重
//   "prom_for_duration": 0,                     // Prometheus持续时间 - 持续满足条件的时间（秒）
//   "prom_ql": "vector(1)",                     // Prometheus查询语句 - 触发告警的查询语句
//   "rule_config": {                            // 规则配置
//     "queries": [                              // 查询配置列表
//       {
//         "prom_ql": "vector(1)",               // Prometheus查询语句
//         "severity": 2,                        // 严重级别
//         "unit": "none"                        // 单位
//       }
//     ]
//   },
//   "prom_eval_interval": 30,                   // Prometheus评估间隔 - 评估规则的间隔时间（秒）
//   "callbacks": [],                            // 回调列表 - 规则触发时调用的回调
//   "runbook_url": "",                          // 运行手册URL - 处理告警的文档链接
//   "notify_recovered": 0,                      // 恢复通知 - 是否发送恢复通知（0:否, 1:是）
//   "target_ident": "",                         // 目标标识 - 告警目标的标识
//   "target_note": "",                          // 目标备注 - 告警目标的描述
//   "trigger_time": 1757903410,                 // 触发时间 - 告警触发的Unix时间戳
//   "trigger_value": "1",                       // 触发值 - 触发告警的具体值
//   "trigger_values": "",                       // 触发值（多值）- 多个触发值的字符串表示
//   "trigger_values_json": {                    // 触发值JSON格式
//     "values_with_unit": {                     // 带单位的值
//       "v": {                                  // 值对象
//         "value": 1,                           // 数值
//         "unit": "",                           // 单位
//         "text": "1.00",                       // 格式化文本
//         "stat": 1                             // 统计值
//       }
//     }
//   },
//   "tags": [                                   // 标签列表 - 格式为"key=value"的字符串数组
//     "rulename=运维团队测试告警11"
//   ],
//   "tags_map": {                               // 标签映射 - key-value形式的标签
//     "rulename": "运维团队测试告警11"
//   },
//   "original_tags": [                          // 原始标签 - 原始的标签字符串数组
//     "rulename=运维团队测试告警11"
//   ],
//   "annotations": {},                          // 注解 - 额外的告警信息
//   "is_recovered": false,                      // 是否已恢复 - 告警是否已恢复
//   "last_eval_time": 1757903410,               // 上次评估时间 - 上次评估规则的时间戳
//   "last_sent_time": 1757903410,               // 上次发送时间 - 上次发送通知的时间戳
//   "first_eval_time": 0,                       // 首次评估时间 - 首次评估规则的时间戳
//   "notify_cur_number": 12307,                 // 通知次数 - 已发送的通知次数
//   "first_trigger_time": 1757149895,           // 首次触发时间 - 第一次触发告警的时间戳
//   "extra_config": {                           // 额外配置
//     "enrich_queries": []                      // 增强查询 - 用于丰富告警信息的查询
//   },
//   "status": 0,                                // 状态 - 0:未恢复, 1:已恢复
//   "claimant": "",                             // 认领人 - 认领该告警的用户
//   "sub_rule_id": 0,                           // 子规则ID - 如果是复合规则，表示子规则ID
//   "extra_info": null,                         // 额外信息 - 其他可能的扩展信息
//   "target": null,                             // 目标 - 告警的具体目标
//   "recover_config": {                         // 恢复配置
//     "judge_type": 0,                          // 判断类型 - 恢复判断方式
//     "recover_exp": ""                         // 恢复表达式 - 恢复条件表达式
//   },
//   "rule_hash": "30529660ec8eaa68a74f8aebab7a363f", // 规则哈希 - 规则内容的哈希值
//   "extra_info_map": null,                     // 额外信息映射 - key-value形式的额外信息
//   "notify_rule_ids": [6],                     // 通知规则ID列表 - 用于发送通知的规则ID
//   "notify_version": 0,                        // 通知版本 - 通知模板的版本
//   "notify_rules": null                        // 通知规则 - 具体的通知规则配置
// }

// AlertData 飞书告警数据结构
// AlertData 飞书告警数据结构
type AlertData struct {
	ID                int                    `json:"id"`                  // 告警ID - 告警的唯一标识符
	Cate              string                 `json:"cate"`                // 告警类别 - 数据源类型（如prometheus）
	Cluster           string                 `json:"cluster"`             // 集群名称 - 产生告警的监控集群标识
	DatasourceID      int                    `json:"datasource_id"`       // 数据源ID - 监控数据源的唯一标识
	GroupID           int                    `json:"group_id"`            // 分组ID - 告警所属的业务分组ID
	GroupName         string                 `json:"group_name"`          // 分组名称 - 告警所属的业务分组名称
	Hash              string                 `json:"hash"`                // 告警哈希 - 用于唯一标识告警内容的哈希值
	RuleID            int                    `json:"rule_id"`             // 规则ID - 触发告警的监控规则ID
	RuleName          string                 `json:"rule_name"`           // 规则名称 - 触发告警的监控规则名称
	RuleNote          string                 `json:"rule_note"`           // 规则备注 - 规则的描述信息
	RuleProd          string                 `json:"rule_prod"`           // 规则产品 - 规则所属的产品类型
	RuleAlgo          string                 `json:"rule_algo"`           // 规则算法 - 使用的告警算法（如simple, complex等）
	Severity          int                    `json:"severity"`            // 严重级别 - 1:提示, 2:警告, 3:严重
	PromForDuration   int                    `json:"prom_for_duration"`   // 持续时间 - 触发告警需要满足条件的持续时间（秒）
	PromQL            string                 `json:"prom_ql"`             // Prometheus查询语句 - 触发告警的查询语句
	RuleConfig        RuleConfig             `json:"rule_config"`         // 规则配置 - 包含查询配置的详细信息
	PromEvalInterval  int                    `json:"prom_eval_interval"`  // 评估间隔 - Prometheus评估规则的间隔时间（秒）
	Callbacks         []interface{}          `json:"callbacks"`           // 回调列表 - 规则触发时调用的回调函数列表
	RunbookURL        string                 `json:"runbook_url"`         // 运行手册URL - 处理该告警的文档链接
	NotifyRecovered   int                    `json:"notify_recovered"`    // 恢复通知 - 是否发送恢复通知（0:否, 1:是）
	TargetIdent       string                 `json:"target_ident"`        // 目标标识 - 告警目标的唯一标识
	TargetNote        string                 `json:"target_note"`         // 目标备注 - 告警目标的描述信息
	TriggerTime       int64                  `json:"trigger_time"`        // 触发时间 - 告警触发的Unix时间戳（秒）
	TriggerValue      string                 `json:"trigger_value"`       // 触发值 - 触发告警的具体数值（字符串形式）
	TriggerValues     string                 `json:"trigger_values"`      // 触发值（多值）- 多个触发值的字符串表示
	TriggerValuesJSON TriggerValuesJSON      `json:"trigger_values_json"` // 触发值JSON格式 - 带单位的触发值详细信息
	Tags              []string               `json:"tags"`                // 标签列表 - 格式为"key=value"的字符串数组
	TagsMap           map[string]string      `json:"tags_map"`            // 标签映射 - key-value形式的标签，便于程序处理
	OriginalTags      []string               `json:"original_tags"`       // 原始标签 - 原始的标签字符串数组
	Annotations       map[string]interface{} `json:"annotations"`         // 注解 - 额外的告警信息（如描述、链接等）
	IsRecovered       bool                   `json:"is_recovered"`        // 是否已恢复 - 告警是否已恢复
	LastEvalTime      int64                  `json:"last_eval_time"`      // 上次评估时间 - 上次评估规则的时间戳（秒）
	LastSentTime      int64                  `json:"last_sent_time"`      // 上次发送时间 - 上次发送通知的时间戳（秒）
	FirstEvalTime     int64                  `json:"first_eval_time"`     // 首次评估时间 - 首次评估规则的时间戳（秒）
	NotifyCurNumber   int                    `json:"notify_cur_number"`   // 通知次数 - 已发送的通知次数
	FirstTriggerTime  int64                  `json:"first_trigger_time"`  // 首次触发时间 - 第一次触发告警的时间戳（秒）
	ExtraConfig       ExtraConfig            `json:"extra_config"`        // 额外配置 - 包含增强查询等额外配置
	Status            int                    `json:"status"`              // 状态 - 0:未恢复, 1:已恢复
	Claimant          string                 `json:"claimant"`            // 认领人 - 认领该告警的用户
	SubRuleID         int                    `json:"sub_rule_id"`         // 子规则ID - 如果是复合规则，表示子规则ID
	ExtraInfo         interface{}            `json:"extra_info"`          // 额外信息 - 其他可能的扩展信息
	Target            interface{}            `json:"target"`              // 目标 - 告警的具体目标对象
	RecoverConfig     RecoverConfig          `json:"recover_config"`      // 恢复配置 - 告警恢复的配置信息
	RuleHash          string                 `json:"rule_hash"`           // 规则哈希 - 规则内容的哈希值，用于检测规则变更
	ExtraInfoMap      interface{}            `json:"extra_info_map"`      // 额外信息映射 - key-value形式的额外信息
	NotifyRuleIDs     []int                  `json:"notify_rule_ids"`     // 通知规则ID列表 - 用于发送通知的规则ID列表
	NotifyVersion     int                    `json:"notify_version"`      // 通知版本 - 通知模板的版本号
	NotifyRules       interface{}            `json:"notify_rules"`        // 通知规则 - 具体的通知规则配置
	FormattedTime     string                 `json:"formatted_time"`      // 额外添加的格式化时间 - 人类可读的触发时间（如"2023-01-01 12:00:00"）
	AlertLevel        string                 `json:"alert_level"`         // 额外添加的告警级别描述 - 人类可读的级别描述（如"警告"）
	TriggerValueText  string                 `json:"trigger_value_text"`  // 额外添加的触发值文本 - 格式化后的触发值（如"1.00"）
}

// RuleConfig 规则配置 - 包含告警规则的查询配置
type RuleConfig struct {
	Queries []Query `json:"queries"` // 查询列表 - 一个规则可能包含多个查询条件
}

// Query 查询配置 - 单个查询条件的配置
type Query struct {
	PromQL   string `json:"prom_ql"`  // Prometheus查询语句 - 该查询的PromQL表达式
	Severity int    `json:"severity"` // 严重级别 - 该查询触发的告警级别
	Unit     string `json:"unit"`     // 单位 - 查询结果的单位（如"ms", "percent"等）
}

// TriggerValuesJSON 触发值JSON - 包含格式化后的触发值信息
type TriggerValuesJSON struct {
	ValuesWithUnit ValuesWithUnit `json:"values_with_unit"` // 带单位的值 - 包含格式化后的触发值
}

// ValuesWithUnit 带单位的值 - 封装了带单位的触发值
type ValuesWithUnit struct {
	V ValueWithUnit `json:"v"` // 值对象 - 实际的触发值及其格式化表示
}

// ValueWithUnit 带单位的单个值 - 触发值的详细信息
type ValueWithUnit struct {
	Value float64 `json:"value"` // 数值 - 原始数值
	Unit  string  `json:"unit"`  // 单位 - 值的单位
	Text  string  `json:"text"`  // 格式化文本 - 人类可读的格式化值（如"1.00"）
	Stat  int     `json:"stat"`  // 统计值 - 可能用于表示统计状态
}

// ExtraConfig 额外配置 - 包含规则的额外配置信息
type ExtraConfig struct {
	EnrichQueries []interface{} `json:"enrich_queries"` // 增强查询列表 - 用于丰富告警信息的查询
}

// RecoverConfig 恢复配置 - 告警恢复的配置信息
type RecoverConfig struct {
	JudgeType  int    `json:"judge_type"`  // 判断类型 - 恢复判断方式（0:简单判断, 1:复杂判断等）
	RecoverExp string `json:"recover_exp"` // 恢复表达式 - 恢复条件的表达式
}

// // AlertData 接收的原始 JSON 数据
// // @Description 告警数据结构
// type AlertData struct {
// 	ID           int               `json:"id" example:"1" description:"告警ID"`
// 	RuleName     string            `json:"rule_name" example:"CPU使用率过高" description:"告警规则名称"`
// 	Cluster      string            `json:"cluster" example:"prod-cluster" description:"集群名称"`
// 	Severity     int               `json:"severity" example:"2" description:"告警级别 1-紧急 2-重要 3-警告 4-信息"`
// 	PromQl       string            `json:"prom_ql" example:"cpu_usage > 80" description:"Prometheus查询语句"`
// 	TriggerTime  int64             `json:"trigger_time" example:"1640995200" description:"触发时间戳"`
// 	TriggerValue string            `json:"trigger_value" example:"85.5" description:"触发值"`
// 	GroupName    string            `json:"group_name" example:"system" description:"告警组名称"`
// 	TagsMap      map[string]string `json:"tags_map" example:"{\"env\":\"prod\",\"service\":\"web\"}" description:"标签映射"`
// 	IsRecovered  bool              `json:"is_recovered" example:"false" description:"是否已恢复"`
// }

// AlertInfo 标准化告警信息（所有平台通用）
// @Description 标准化告警信息
type AlertInfo struct {
	ID            string            `json:"id" example:"1" description:"告警ID"`
	Cate          string            `json:"cate"` // 告警类别 - 数据源类型（如prometheus）
	RuleName      string            `json:"rule_name" example:"CPU使用率过高" description:"告警规则名称"`
	Cluster       string            `json:"cluster" example:"prod-cluster" description:"集群名称"`
	Severity      int               `json:"severity" example:"2" description:"告警级别"`
	SeverityText  string            `json:"severity_text" example:"重要" description:"告警级别文本"`
	PromQl        string            `json:"prom_ql" example:"cpu_usage > 80" description:"Prometheus查询语句"`
	TriggerTime   int64             `json:"trigger_time" example:"1640995200" description:"触发时间戳"`
	TriggerValue  string            `json:"trigger_value" example:"85.5" description:"触发值"`
	GroupName     string            `json:"group_name" example:"system" description:"告警组名称"`
	TagsMap       map[string]string `json:"tags_map" example:"{\"env\":\"prod\"}" description:"标签映射"`
	IsRecovered   bool              `json:"is_recovered" example:"false" description:"是否已恢复"`
	FormattedTime string            `json:"formatted_time" example:"2022-01-01 12:00:00" description:"格式化时间"`
	GroupID       int               `json:"group_id"`      // 分组ID - 告警所属的业务分组ID
	DatasourceID  int               `json:"datasource_id"` // 数据源ID - 监控数据源的唯一标识
}

// 转 severity 数字为中文
func severityToText(sev int) string {
	switch sev {
	case 1:
		return "紧急"
	case 2:
		return "重要"
	case 3:
		return "警告"
	case 4:
		return "信息"
	default:
		return "未知"
	}
}

// 转 severity 为 emoji 前缀
func (a *AlertInfo) EmojiPrefix() string {
	switch a.Severity {
	case 1:
		return "🔴 紧急"
	case 2:
		return "🟠 重要"
	case 3:
		return "🟡 警告"
	default:
		return "🔵 信息"
	}
}

// FromAlertData 从原始数据构建标准化告警
func (a *AlertInfo) FromAlertData(data AlertData) {
	a.RuleName = data.RuleName
	a.Cluster = data.Cluster
	a.Severity = data.Severity
	a.SeverityText = severityToText(data.Severity)
	a.PromQl = data.PromQL
	a.TriggerTime = data.TriggerTime
	a.TriggerValue = data.TriggerValue
	a.GroupID = data.GroupID
	a.Cate = data.Cate
	a.GroupName = data.GroupName
	a.TagsMap = data.TagsMap
	a.IsRecovered = data.IsRecovered
	a.DatasourceID = data.DatasourceID
	a.FormattedTime = time.Unix(data.TriggerTime, 0).Format("2006-01-02 15:04:05")
	a.ID = strconv.Itoa(data.ID)
}

// FormatTriggerValue 返回格式化的触发值
func (a *AlertData) FormatTriggerValue() string {
	if a.TriggerValuesJSON.ValuesWithUnit.V.Text != "" {
		return a.TriggerValuesJSON.ValuesWithUnit.V.Text
	}
	return a.TriggerValue
}

// FormatTime 格式化时间
func (a *AlertData) FormatTime(timestamp int64) string {
	return time.Unix(timestamp, 0).Format("2006-01-02 15:04:05")
}

// FormatTags 格式化标签
func (a *AlertData) FormatTags() string {
	if len(a.TagsMap) == 0 {
		return "无标签"
	}

	var result string
	for k, v := range a.TagsMap {
		result += fmt.Sprintf("- `%s`: `%s`\n", k, v)
	}
	return result
}
